Mestre Django-signaler: Dypdykk i Post-save og Pre-delete Hooks for robuste applikasjoner

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User

# Definer en mottakerfunksjon
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        # Logikk for å opprette en profil for den nye brukeren
        print(f"Ny bruker '{instance.username}' opprettet. En profil kan nå genereres.")

# Alternativt, koble til manuelt (mindre vanlig med dekorator for innebygde signaler)
# from django.apps import AppConfig
# class MyAppConfig(AppConfig):
#     name = 'myapp'
#     def ready(self):
#         from . import signals  # Importer signalfilen din

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)
    birth_date = models.DateField(null=True, blank=True)

    def __str__(self):
        return self.user.username + "'s Profile"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import UserProfile

@receiver(post_save, sender=User)
def create_or_update_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)
        print(f"UserProfile for {instance.username} opprettet.")
    # Valgfritt: Hvis du også vil håndtere oppdateringer av User og kaskadere til profilen
    # instance.userprofile.save() # Dette ville utløst post_save for UserProfile hvis du hadde en

            

              
                Copy
              
            
          

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product
from django.core.cache import cache

@receiver(post_save, sender=Product)
def update_product_cache_and_search_index(sender, instance, **kwargs):
    # Ugyldiggjør spesifikk produkt-cache
    cache.delete(f"product_detail_{instance.pk}")
    print(f"Cache ugyldiggjort for produkt-ID: {instance.pk}")

    # Simulerer oppdatering av en søkeindeks
    # I et virkelig scenario kan dette innebære å kalle et eksternt søketjeneste-API
    print(f"Produkt {instance.name} (ID: {instance.pk}) merket for oppdatering av søkeindeks.")
    # search_service.index_document(instance)

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class AuditLog(models.Model):
    model_name = models.CharField(max_length=255)
    object_id = models.IntegerField()
    action = models.CharField(max_length=50) # 'created', 'updated'
    timestamp = models.DateTimeField(auto_now_add=True)
    changes = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"[{self.timestamp}] {self.model_name}({self.object_id}) {self.action}"

class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import AuditLog, BlogPost # Eksempelmodell å revidere

@receiver(post_save, sender=BlogPost)
def log_blogpost_changes(sender, instance, created, **kwargs):
    action = 'created' if created else 'updated'
    # For oppdateringer kan det være lurt å fange opp spesifikke feltendringer. Krever sammenligning før lagring.
    # For enkelhets skyld logger vi bare handlingen her.
    AuditLog.objects.create(
        model_name=sender.__name__,
        object_id=instance.pk,
        action=action,
        # changes=previous_state_vs_current_state # Mer kompleks logikk kreves for dette
    )
    print(f"Revisjonslogg opprettet for BlogPost ID: {instance.pk}, handling: {action}")

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Order(models.Model):
    customer_email = models.EmailField()
    status = models.CharField(max_length=50, default='pending')
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return f"Order #{self.pk} - {self.customer_email}"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Order
from django.core.mail import send_mail
# from myapp.tasks import send_order_confirmation_email_task # For asynkrone oppgaver

@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created and instance.status == 'pending': # Eller 'completed' hvis behandlet synkront
        subject = f"Din ordrebekreftelse #{instance.pk}"
        message = f"Kjære kunde, takk for din bestilling! Din ordresum er {instance.total_amount}."
        from_email = "noreply@example.com"
        recipient_list = [instance.customer_email]

        try:
            send_mail(subject, message, from_email, recipient_list, fail_silently=False)
            print(f"Ordrebekreftelse sendt til {instance.customer_email} for Ordre-ID: {instance.pk}")
        except Exception as e:
            print(f"Feil ved sending av e-post for Ordre-ID {instance.pk}: {e}")

        # For bedre ytelse og pålitelighet, spesielt med eksterne tjenester,
        # vurder å utsette dette til en asynkron oppgavekø (f.eks. Celery).
        # send_order_confirmation_email_task.delay(instance.pk)

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Document(models.Model):
    title = models.CharField(max_length=255)
    file = models.FileField(upload_to='documents/')

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Document

@receiver(pre_delete, sender=Document)
def delete_document_file_on_delete(sender, instance, **kwargs):
    # Sørg for at filen eksisterer før du prøver å slette den
    if instance.file:
        instance.file.delete(save=False) # slett den faktiske filen fra lagring
        print(f"Filen '{instance.file.name}' for Dokument-ID: {instance.pk} slettet fra lagring.")

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class Customer(models.Model):
    name = models.CharField(max_length=255)
    email = models.EmailField(unique=True)
    is_active = models.BooleanField(default=True)
    archived_at = models.DateTimeField(null=True, blank=True)

    def __str__(self):
        return self.name

class ArchivedCustomer(models.Model):
    original_customer_id = models.IntegerField(unique=True)
    name = models.CharField(max_length=255)
    email = models.EmailField()
    archived_date = models.DateTimeField(auto_now_add=True)
    original_data_snapshot = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"Arkivert: {self.name} (ID: {self.original_customer_id})"

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Customer, ArchivedCustomer
from django.core.exceptions import PermissionDenied # For å forhindre faktisk sletting
from django.utils import timezone

@receiver(pre_delete, sender=Customer)
def archive_customer_instead_of_delete(sender, instance, **kwargs):
    # Opprett en arkivert kopi
    ArchivedCustomer.objects.create(
        original_customer_id=instance.pk,
        name=instance.name,
        email=instance.email,
        original_data_snapshot={
            'is_active': instance.is_active,
            'archived_at': instance.archived_at.isoformat() if instance.archived_at else None
        }
    )
    print(f"Kunde-ID: {instance.pk} arkivert i stedet for slettet.")
    # Forhindre at den faktiske slettingen fortsetter ved å heve en unntakelse
    raise PermissionDenied(f"Kunden '{instance.name}' kan ikke hard-slettes, kun arkiveres.")
    # Merk: For et ekte myk-slettingsmønster, ville man typisk overstyre delete()-metoden
    # på modellen eller bruke en tilpasset manager, da signaler ikke enkelt kan "avbryte" en ORM-operasjon.
```

# myapp/models.py
from django.db import models

class Project(models.Model):
    title = models.CharField(max_length=255)
    description = models.TextField(blank=True)

    def __str__(self):
        return self.title

class Task(models.Model):
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    name = models.CharField(max_length=255)
    is_completed = models.BooleanField(default=False)

    def __str__(self):
        return self.name

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Project, Task
from django.core.exceptions import PermissionDenied

@receiver(pre_delete, sender=Project)
def prevent_deletion_if_active_tasks(sender, instance, **kwargs):
    if instance.task_set.filter(is_completed=False).exists():
        raise PermissionDenied(
            f"Kan ikke slette prosjektet '{instance.title}' fordi det fortsatt har aktive oppgaver."
        )
    print(f"Prosjektet '{instance.title}' har ingen aktive oppgaver; sletting fortsetter.")

            

              
                Copy